use ::libc;
extern "C" {
    pub type event_base;
    pub type evbuffer;
    pub type bufferevent_ops;
    pub type args;
    pub type tmuxpeer;
    pub type hyperlinks;
    pub type screen_write_cline;
    pub type screen_sel;
    pub type screen_titles;
    pub type environ;
    pub type options;
    pub type format_tree;
    pub type input_ctx;
    pub type cmds;
    pub type tty_key;
    pub type tty_code;
    pub type format_job_tree;
    pub type control_state;
    pub type cmdq_list;
    fn free(_: *mut libc::c_void);
    fn xmalloc(_: size_t) -> *mut libc::c_void;
    fn notify_window(_: *const libc::c_char, _: *mut window);
    fn options_get_number(_: *mut options, _: *const libc::c_char) -> libc::c_longlong;
    fn window_pane_resize(_: *mut window_pane, _: u_int, _: u_int);
    fn window_pane_show_scrollbar(_: *mut window_pane, _: libc::c_int) -> libc::c_int;
    fn fatalx(_: *const libc::c_char, _: ...) -> !;
    fn log_debug(_: *const libc::c_char, _: ...);
}
pub type __u_char = libc::c_uchar;
pub type __u_short = libc::c_ushort;
pub type __u_int = libc::c_uint;
pub type __uint8_t = libc::c_uchar;
pub type __uint64_t = libc::c_ulong;
pub type __pid_t = libc::c_int;
pub type __time_t = libc::c_long;
pub type __suseconds_t = libc::c_long;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type pid_t = __pid_t;
pub type time_t = __time_t;
pub type size_t = libc::c_ulong;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
pub type cc_t = libc::c_uchar;
pub type speed_t = libc::c_uint;
pub type tcflag_t = libc::c_uint;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct termios {
    pub c_iflag: tcflag_t,
    pub c_oflag: tcflag_t,
    pub c_cflag: tcflag_t,
    pub c_lflag: tcflag_t,
    pub c_line: cc_t,
    pub c_cc: [cc_t; 32],
    pub c_ispeed: speed_t,
    pub c_ospeed: speed_t,
}
pub type uint8_t = __uint8_t;
pub type uint64_t = __uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event {
    pub ev_evcallback: event_callback,
    pub ev_timeout_pos: C2RustUnnamed_4,
    pub ev_fd: libc::c_int,
    pub ev_base: *mut event_base,
    pub ev_: C2RustUnnamed,
    pub ev_events: libc::c_short,
    pub ev_res: libc::c_short,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
    pub ev_io: C2RustUnnamed_2,
    pub ev_signal: C2RustUnnamed_0,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
    pub ev_signal_next: C2RustUnnamed_1,
    pub ev_ncalls: libc::c_short,
    pub ev_pncalls: *mut libc::c_short,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub ev_io_next: C2RustUnnamed_3,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_3 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_4 {
    pub ev_next_with_common_timeout: C2RustUnnamed_5,
    pub min_heap_idx: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_5 {
    pub tqe_next: *mut event,
    pub tqe_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_callback {
    pub evcb_active_next: C2RustUnnamed_7,
    pub evcb_flags: libc::c_short,
    pub evcb_pri: uint8_t,
    pub evcb_closure: uint8_t,
    pub evcb_cb_union: C2RustUnnamed_6,
    pub evcb_arg: *mut libc::c_void,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_6 {
    pub evcb_callback:
        Option<unsafe extern "C" fn(libc::c_int, libc::c_short, *mut libc::c_void) -> ()>,
    pub evcb_selfcb: Option<unsafe extern "C" fn(*mut event_callback, *mut libc::c_void) -> ()>,
    pub evcb_evfinalize: Option<unsafe extern "C" fn(*mut event, *mut libc::c_void) -> ()>,
    pub evcb_cbfinalize: Option<unsafe extern "C" fn(*mut event_callback, *mut libc::c_void) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_7 {
    pub tqe_next: *mut event_callback,
    pub tqe_prev: *mut *mut event_callback,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct bufferevent {
    pub ev_base: *mut event_base,
    pub be_ops: *const bufferevent_ops,
    pub ev_read: event,
    pub ev_write: event,
    pub input: *mut evbuffer,
    pub output: *mut evbuffer,
    pub wm_read: event_watermark,
    pub wm_write: event_watermark,
    pub readcb: bufferevent_data_cb,
    pub writecb: bufferevent_data_cb,
    pub errorcb: bufferevent_event_cb,
    pub cbarg: *mut libc::c_void,
    pub timeout_read: timeval,
    pub timeout_write: timeval,
    pub enabled: libc::c_short,
}
pub type bufferevent_event_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, libc::c_short, *mut libc::c_void) -> ()>;
pub type bufferevent_data_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, *mut libc::c_void) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_watermark {
    pub low: size_t,
    pub high: size_t,
}
pub type bitstr_t = libc::c_uchar;
pub type msgtype = libc::c_uint;
pub const MSG_READ_CANCEL: msgtype = 307;
pub const MSG_WRITE_CLOSE: msgtype = 306;
pub const MSG_WRITE_READY: msgtype = 305;
pub const MSG_WRITE: msgtype = 304;
pub const MSG_WRITE_OPEN: msgtype = 303;
pub const MSG_READ_DONE: msgtype = 302;
pub const MSG_READ: msgtype = 301;
pub const MSG_READ_OPEN: msgtype = 300;
pub const MSG_FLAGS: msgtype = 218;
pub const MSG_EXEC: msgtype = 217;
pub const MSG_WAKEUP: msgtype = 216;
pub const MSG_UNLOCK: msgtype = 215;
pub const MSG_SUSPEND: msgtype = 214;
pub const MSG_OLDSTDOUT: msgtype = 213;
pub const MSG_OLDSTDIN: msgtype = 212;
pub const MSG_OLDSTDERR: msgtype = 211;
pub const MSG_SHUTDOWN: msgtype = 210;
pub const MSG_SHELL: msgtype = 209;
pub const MSG_RESIZE: msgtype = 208;
pub const MSG_READY: msgtype = 207;
pub const MSG_LOCK: msgtype = 206;
pub const MSG_EXITING: msgtype = 205;
pub const MSG_EXITED: msgtype = 204;
pub const MSG_EXIT: msgtype = 203;
pub const MSG_DETACHKILL: msgtype = 202;
pub const MSG_DETACH: msgtype = 201;
pub const MSG_COMMAND: msgtype = 200;
pub const MSG_IDENTIFY_TERMINFO: msgtype = 112;
pub const MSG_IDENTIFY_LONGFLAGS: msgtype = 111;
pub const MSG_IDENTIFY_STDOUT: msgtype = 110;
pub const MSG_IDENTIFY_FEATURES: msgtype = 109;
pub const MSG_IDENTIFY_CWD: msgtype = 108;
pub const MSG_IDENTIFY_CLIENTPID: msgtype = 107;
pub const MSG_IDENTIFY_DONE: msgtype = 106;
pub const MSG_IDENTIFY_ENVIRON: msgtype = 105;
pub const MSG_IDENTIFY_STDIN: msgtype = 104;
pub const MSG_IDENTIFY_OLDCWD: msgtype = 103;
pub const MSG_IDENTIFY_TTYNAME: msgtype = 102;
pub const MSG_IDENTIFY_TERM: msgtype = 101;
pub const MSG_IDENTIFY_FLAGS: msgtype = 100;
pub const MSG_VERSION: msgtype = 12;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client {
    pub name: *const libc::c_char,
    pub peer: *mut tmuxpeer,
    pub queue: *mut cmdq_list,
    pub windows: client_windows,
    pub control_state: *mut control_state,
    pub pause_age: u_int,
    pub pid: pid_t,
    pub fd: libc::c_int,
    pub out_fd: libc::c_int,
    pub event: event,
    pub retval: libc::c_int,
    pub creation_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub environ: *mut environ,
    pub jobs: *mut format_job_tree,
    pub title: *mut libc::c_char,
    pub path: *mut libc::c_char,
    pub cwd: *const libc::c_char,
    pub term_name: *mut libc::c_char,
    pub term_features: libc::c_int,
    pub term_type: *mut libc::c_char,
    pub term_caps: *mut *mut libc::c_char,
    pub term_ncaps: u_int,
    pub ttyname: *mut libc::c_char,
    pub tty: tty,
    pub written: size_t,
    pub discarded: size_t,
    pub redraw: size_t,
    pub repeat_timer: event,
    pub click_timer: event,
    pub click_button: u_int,
    pub click_event: mouse_event,
    pub status: status_line,
    pub flags: uint64_t,
    pub exit_type: C2RustUnnamed_30,
    pub exit_msgtype: msgtype,
    pub exit_session: *mut libc::c_char,
    pub exit_message: *mut libc::c_char,
    pub keytable: *mut key_table,
    pub last_key: key_code,
    pub redraw_panes: uint64_t,
    pub redraw_scrollbars: uint64_t,
    pub message_ignore_keys: libc::c_int,
    pub message_ignore_styles: libc::c_int,
    pub message_string: *mut libc::c_char,
    pub message_timer: event,
    pub prompt_string: *mut libc::c_char,
    pub prompt_buffer: *mut utf8_data,
    pub prompt_last: *mut libc::c_char,
    pub prompt_index: size_t,
    pub prompt_inputcb: prompt_input_cb,
    pub prompt_freecb: prompt_free_cb,
    pub prompt_data: *mut libc::c_void,
    pub prompt_hindex: [u_int; 4],
    pub prompt_mode: C2RustUnnamed_27,
    pub prompt_saved: *mut utf8_data,
    pub prompt_flags: libc::c_int,
    pub prompt_type: prompt_type,
    pub prompt_cursor: libc::c_int,
    pub session: *mut session,
    pub last_session: *mut session,
    pub references: libc::c_int,
    pub pan_window: *mut libc::c_void,
    pub pan_ox: u_int,
    pub pan_oy: u_int,
    pub overlay_check: overlay_check_cb,
    pub overlay_mode: overlay_mode_cb,
    pub overlay_draw: overlay_draw_cb,
    pub overlay_key: overlay_key_cb,
    pub overlay_free: overlay_free_cb,
    pub overlay_resize: overlay_resize_cb,
    pub overlay_data: *mut libc::c_void,
    pub overlay_timer: event,
    pub files: client_files,
    pub clipboard_panes: *mut u_int,
    pub clipboard_npanes: u_int,
    pub entry: C2RustUnnamed_8,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_8 {
    pub tqe_next: *mut client,
    pub tqe_prev: *mut *mut client,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_files {
    pub rbh_root: *mut client_file,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_file {
    pub c: *mut client,
    pub peer: *mut tmuxpeer,
    pub tree: *mut client_files,
    pub references: libc::c_int,
    pub stream: libc::c_int,
    pub path: *mut libc::c_char,
    pub buffer: *mut evbuffer,
    pub event: *mut bufferevent,
    pub fd: libc::c_int,
    pub error: libc::c_int,
    pub closed: libc::c_int,
    pub cb: client_file_cb,
    pub data: *mut libc::c_void,
    pub entry: C2RustUnnamed_9,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_9 {
    pub rbe_left: *mut client_file,
    pub rbe_right: *mut client_file,
    pub rbe_parent: *mut client_file,
    pub rbe_color: libc::c_int,
}
pub type client_file_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *const libc::c_char,
        libc::c_int,
        libc::c_int,
        *mut evbuffer,
        *mut libc::c_void,
    ) -> (),
>;
pub type overlay_resize_cb = Option<unsafe extern "C" fn(*mut client, *mut libc::c_void) -> ()>;
pub type overlay_free_cb = Option<unsafe extern "C" fn(*mut client, *mut libc::c_void) -> ()>;
pub type overlay_key_cb =
    Option<unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut key_event) -> libc::c_int>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_event {
    pub key: key_code,
    pub m: mouse_event,
    pub buf: *mut libc::c_char,
    pub len: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mouse_event {
    pub valid: libc::c_int,
    pub ignore: libc::c_int,
    pub key: key_code,
    pub statusat: libc::c_int,
    pub statuslines: u_int,
    pub x: u_int,
    pub y: u_int,
    pub b: u_int,
    pub lx: u_int,
    pub ly: u_int,
    pub lb: u_int,
    pub ox: u_int,
    pub oy: u_int,
    pub s: libc::c_int,
    pub w: libc::c_int,
    pub wp: libc::c_int,
    pub sgr_type: u_int,
    pub sgr_b: u_int,
}
pub type key_code = libc::c_ulonglong;
pub type overlay_draw_cb =
    Option<unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut screen_redraw_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_redraw_ctx {
    pub c: *mut client,
    pub statuslines: u_int,
    pub statustop: libc::c_int,
    pub pane_status: libc::c_int,
    pub pane_lines: pane_lines,
    pub pane_scrollbars: libc::c_int,
    pub pane_scrollbars_pos: libc::c_int,
    pub no_pane_gc: grid_cell,
    pub no_pane_gc_set: libc::c_int,
    pub sx: u_int,
    pub sy: u_int,
    pub ox: u_int,
    pub oy: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_cell {
    pub data: utf8_data,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: libc::c_int,
    pub bg: libc::c_int,
    pub us: libc::c_int,
    pub link: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct utf8_data {
    pub data: [u_char; 21],
    pub have: u_char,
    pub size: u_char,
    pub width: u_char,
}
pub type pane_lines = libc::c_uint;
pub const PANE_LINES_NUMBER: pane_lines = 4;
pub const PANE_LINES_SIMPLE: pane_lines = 3;
pub const PANE_LINES_HEAVY: pane_lines = 2;
pub const PANE_LINES_DOUBLE: pane_lines = 1;
pub const PANE_LINES_SINGLE: pane_lines = 0;
pub type overlay_mode_cb = Option<
    unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut u_int, *mut u_int) -> *mut screen,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen {
    pub title: *mut libc::c_char,
    pub path: *mut libc::c_char,
    pub titles: *mut screen_titles,
    pub grid: *mut grid,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub default_cstyle: screen_cursor_style,
    pub ccolour: libc::c_int,
    pub default_ccolour: libc::c_int,
    pub rupper: u_int,
    pub rlower: u_int,
    pub mode: libc::c_int,
    pub default_mode: libc::c_int,
    pub saved_cx: u_int,
    pub saved_cy: u_int,
    pub saved_grid: *mut grid,
    pub saved_cell: grid_cell,
    pub saved_flags: libc::c_int,
    pub tabs: *mut bitstr_t,
    pub sel: *mut screen_sel,
    pub write_list: *mut screen_write_cline,
    pub hyperlinks: *mut hyperlinks,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid {
    pub flags: libc::c_int,
    pub sx: u_int,
    pub sy: u_int,
    pub hscrolled: u_int,
    pub hsize: u_int,
    pub hlimit: u_int,
    pub linedata: *mut grid_line,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_line {
    pub celldata: *mut grid_cell_entry,
    pub cellused: u_int,
    pub cellsize: u_int,
    pub extddata: *mut grid_extd_entry,
    pub extdsize: u_int,
    pub flags: libc::c_int,
    pub time: time_t,
}
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_extd_entry {
    pub data: utf8_char,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: libc::c_int,
    pub bg: libc::c_int,
    pub us: libc::c_int,
    pub link: u_int,
}
pub type utf8_char = u_int;
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_cell_entry {
    pub c2rust_unnamed: C2RustUnnamed_10,
    pub flags: u_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_10 {
    pub offset: u_int,
    pub data: C2RustUnnamed_11,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_11 {
    pub attr: u_char,
    pub fg: u_char,
    pub bg: u_char,
    pub data: u_char,
}
pub type screen_cursor_style = libc::c_uint;
pub const SCREEN_CURSOR_BAR: screen_cursor_style = 3;
pub const SCREEN_CURSOR_UNDERLINE: screen_cursor_style = 2;
pub const SCREEN_CURSOR_BLOCK: screen_cursor_style = 1;
pub const SCREEN_CURSOR_DEFAULT: screen_cursor_style = 0;
pub type overlay_check_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut libc::c_void,
        u_int,
        u_int,
        u_int,
        *mut overlay_ranges,
    ) -> (),
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct overlay_ranges {
    pub px: [u_int; 3],
    pub nx: [u_int; 3],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct session {
    pub id: u_int,
    pub name: *mut libc::c_char,
    pub cwd: *const libc::c_char,
    pub creation_time: timeval,
    pub last_attached_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub lock_timer: event,
    pub curw: *mut winlink,
    pub lastw: winlink_stack,
    pub windows: winlinks,
    pub statusat: libc::c_int,
    pub statuslines: u_int,
    pub options: *mut options,
    pub flags: libc::c_int,
    pub attached: u_int,
    pub tio: *mut termios,
    pub environ: *mut environ,
    pub references: libc::c_int,
    pub gentry: C2RustUnnamed_13,
    pub entry: C2RustUnnamed_12,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_12 {
    pub rbe_left: *mut session,
    pub rbe_right: *mut session,
    pub rbe_parent: *mut session,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_13 {
    pub tqe_next: *mut session,
    pub tqe_prev: *mut *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlinks {
    pub rbh_root: *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink {
    pub idx: libc::c_int,
    pub session: *mut session,
    pub window: *mut window,
    pub flags: libc::c_int,
    pub entry: C2RustUnnamed_16,
    pub wentry: C2RustUnnamed_15,
    pub sentry: C2RustUnnamed_14,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_14 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_15 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_16 {
    pub rbe_left: *mut winlink,
    pub rbe_right: *mut winlink,
    pub rbe_parent: *mut winlink,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window {
    pub id: u_int,
    pub latest: *mut libc::c_void,
    pub name: *mut libc::c_char,
    pub name_event: event,
    pub name_time: timeval,
    pub alerts_timer: event,
    pub offset_timer: event,
    pub activity_time: timeval,
    pub active: *mut window_pane,
    pub last_panes: window_panes,
    pub panes: window_panes,
    pub lastlayout: libc::c_int,
    pub layout_root: *mut layout_cell,
    pub saved_layout_root: *mut layout_cell,
    pub old_layout: *mut libc::c_char,
    pub sx: u_int,
    pub sy: u_int,
    pub manual_sx: u_int,
    pub manual_sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub new_sx: u_int,
    pub new_sy: u_int,
    pub new_xpixel: u_int,
    pub new_ypixel: u_int,
    pub fill_character: *mut utf8_data,
    pub flags: libc::c_int,
    pub alerts_queued: libc::c_int,
    pub alerts_entry: C2RustUnnamed_19,
    pub options: *mut options,
    pub references: u_int,
    pub winlinks: C2RustUnnamed_18,
    pub entry: C2RustUnnamed_17,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_17 {
    pub rbe_left: *mut window,
    pub rbe_right: *mut window,
    pub rbe_parent: *mut window,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_18 {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_19 {
    pub tqe_next: *mut window,
    pub tqe_prev: *mut *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cell {
    pub type_0: layout_type,
    pub parent: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub wp: *mut window_pane,
    pub cells: layout_cells,
    pub entry: C2RustUnnamed_20,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_20 {
    pub tqe_next: *mut layout_cell,
    pub tqe_prev: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cells {
    pub tqh_first: *mut layout_cell,
    pub tqh_last: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane {
    pub id: u_int,
    pub active_point: u_int,
    pub window: *mut window,
    pub options: *mut options,
    pub layout_cell: *mut layout_cell,
    pub saved_layout_cell: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub flags: libc::c_int,
    pub sb_slider_y: u_int,
    pub sb_slider_h: u_int,
    pub argc: libc::c_int,
    pub argv: *mut *mut libc::c_char,
    pub shell: *mut libc::c_char,
    pub cwd: *mut libc::c_char,
    pub pid: pid_t,
    pub tty: [libc::c_char; 32],
    pub status: libc::c_int,
    pub dead_time: timeval,
    pub fd: libc::c_int,
    pub event: *mut bufferevent,
    pub offset: window_pane_offset,
    pub base_offset: size_t,
    pub resize_queue: window_pane_resizes,
    pub resize_timer: event,
    pub ictx: *mut input_ctx,
    pub cached_gc: grid_cell,
    pub cached_active_gc: grid_cell,
    pub palette: colour_palette,
    pub pipe_fd: libc::c_int,
    pub pipe_event: *mut bufferevent,
    pub pipe_offset: window_pane_offset,
    pub screen: *mut screen,
    pub base: screen,
    pub status_screen: screen,
    pub status_size: size_t,
    pub modes: C2RustUnnamed_24,
    pub searchstr: *mut libc::c_char,
    pub searchregex: libc::c_int,
    pub border_gc_set: libc::c_int,
    pub border_gc: grid_cell,
    pub control_bg: libc::c_int,
    pub control_fg: libc::c_int,
    pub scrollbar_style: style,
    pub entry: C2RustUnnamed_23,
    pub sentry: C2RustUnnamed_22,
    pub tree_entry: C2RustUnnamed_21,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_21 {
    pub rbe_left: *mut window_pane,
    pub rbe_right: *mut window_pane,
    pub rbe_parent: *mut window_pane,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_22 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_23 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style {
    pub gc: grid_cell,
    pub ignore: libc::c_int,
    pub fill: libc::c_int,
    pub align: style_align,
    pub list: style_list,
    pub range_type: style_range_type,
    pub range_argument: u_int,
    pub range_string: [libc::c_char; 16],
    pub width: libc::c_int,
    pub pad: libc::c_int,
    pub default_type: style_default_type,
}
pub type style_default_type = libc::c_uint;
pub const STYLE_DEFAULT_POP: style_default_type = 2;
pub const STYLE_DEFAULT_PUSH: style_default_type = 1;
pub const STYLE_DEFAULT_BASE: style_default_type = 0;
pub type style_range_type = libc::c_uint;
pub const STYLE_RANGE_USER: style_range_type = 6;
pub const STYLE_RANGE_SESSION: style_range_type = 5;
pub const STYLE_RANGE_WINDOW: style_range_type = 4;
pub const STYLE_RANGE_PANE: style_range_type = 3;
pub const STYLE_RANGE_RIGHT: style_range_type = 2;
pub const STYLE_RANGE_LEFT: style_range_type = 1;
pub const STYLE_RANGE_NONE: style_range_type = 0;
pub type style_list = libc::c_uint;
pub const STYLE_LIST_RIGHT_MARKER: style_list = 4;
pub const STYLE_LIST_LEFT_MARKER: style_list = 3;
pub const STYLE_LIST_FOCUS: style_list = 2;
pub const STYLE_LIST_ON: style_list = 1;
pub const STYLE_LIST_OFF: style_list = 0;
pub type style_align = libc::c_uint;
pub const STYLE_ALIGN_ABSOLUTE_CENTRE: style_align = 4;
pub const STYLE_ALIGN_RIGHT: style_align = 3;
pub const STYLE_ALIGN_CENTRE: style_align = 2;
pub const STYLE_ALIGN_LEFT: style_align = 1;
pub const STYLE_ALIGN_DEFAULT: style_align = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_24 {
    pub tqh_first: *mut window_mode_entry,
    pub tqh_last: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode_entry {
    pub wp: *mut window_pane,
    pub swp: *mut window_pane,
    pub mode: *const window_mode,
    pub data: *mut libc::c_void,
    pub screen: *mut screen,
    pub prefix: u_int,
    pub entry: C2RustUnnamed_25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_25 {
    pub tqe_next: *mut window_mode_entry,
    pub tqe_prev: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode {
    pub name: *const libc::c_char,
    pub default_format: *const libc::c_char,
    pub init: Option<
        unsafe extern "C" fn(*mut window_mode_entry, *mut cmd_find_state, *mut args) -> *mut screen,
    >,
    pub free: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub resize: Option<unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> ()>,
    pub update: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub key: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            key_code,
            *mut mouse_event,
        ) -> (),
    >,
    pub key_table: Option<unsafe extern "C" fn(*mut window_mode_entry) -> *const libc::c_char>,
    pub command: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            *mut args,
            *mut mouse_event,
        ) -> (),
    >,
    pub formats: Option<unsafe extern "C" fn(*mut window_mode_entry, *mut format_tree) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_find_state {
    pub flags: libc::c_int,
    pub current: *mut cmd_find_state,
    pub s: *mut session,
    pub wl: *mut winlink,
    pub w: *mut window,
    pub wp: *mut window_pane,
    pub idx: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_offset {
    pub used: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct colour_palette {
    pub fg: libc::c_int,
    pub bg: libc::c_int,
    pub palette: *mut libc::c_int,
    pub default_palette: *mut libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resizes {
    pub tqh_first: *mut window_pane_resize,
    pub tqh_last: *mut *mut window_pane_resize,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resize {
    pub sx: u_int,
    pub sy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub entry: C2RustUnnamed_26,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_26 {
    pub tqe_next: *mut window_pane_resize,
    pub tqe_prev: *mut *mut window_pane_resize,
}
pub type layout_type = libc::c_uint;
pub const LAYOUT_WINDOWPANE: layout_type = 2;
pub const LAYOUT_TOPBOTTOM: layout_type = 1;
pub const LAYOUT_LEFTRIGHT: layout_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_panes {
    pub tqh_first: *mut window_pane,
    pub tqh_last: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink_stack {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
pub type prompt_type = libc::c_uint;
pub const PROMPT_TYPE_INVALID: prompt_type = 255;
pub const PROMPT_TYPE_WINDOW_TARGET: prompt_type = 3;
pub const PROMPT_TYPE_TARGET: prompt_type = 2;
pub const PROMPT_TYPE_SEARCH: prompt_type = 1;
pub const PROMPT_TYPE_COMMAND: prompt_type = 0;
pub type C2RustUnnamed_27 = libc::c_uint;
pub const PROMPT_COMMAND: C2RustUnnamed_27 = 1;
pub const PROMPT_ENTRY: C2RustUnnamed_27 = 0;
pub type prompt_free_cb = Option<unsafe extern "C" fn(*mut libc::c_void) -> ()>;
pub type prompt_input_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut libc::c_void,
        *const libc::c_char,
        libc::c_int,
    ) -> libc::c_int,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_table {
    pub name: *const libc::c_char,
    pub activity_time: timeval,
    pub key_bindings: key_bindings,
    pub default_key_bindings: key_bindings,
    pub references: u_int,
    pub entry: C2RustUnnamed_28,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_28 {
    pub rbe_left: *mut key_table,
    pub rbe_right: *mut key_table,
    pub rbe_parent: *mut key_table,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_bindings {
    pub rbh_root: *mut key_binding,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_binding {
    pub key: key_code,
    pub cmdlist: *mut cmd_list,
    pub note: *const libc::c_char,
    pub flags: libc::c_int,
    pub entry: C2RustUnnamed_29,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_29 {
    pub rbe_left: *mut key_binding,
    pub rbe_right: *mut key_binding,
    pub rbe_parent: *mut key_binding,
    pub rbe_color: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_list {
    pub references: libc::c_int,
    pub group: u_int,
    pub list: *mut cmds,
}
pub type C2RustUnnamed_30 = libc::c_uint;
pub const CLIENT_EXIT_DETACH: C2RustUnnamed_30 = 2;
pub const CLIENT_EXIT_SHUTDOWN: C2RustUnnamed_30 = 1;
pub const CLIENT_EXIT_RETURN: C2RustUnnamed_30 = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line {
    pub timer: event,
    pub screen: screen,
    pub active: *mut screen,
    pub references: libc::c_int,
    pub style: grid_cell,
    pub entries: [status_line_entry; 5],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line_entry {
    pub expanded: *mut libc::c_char,
    pub ranges: style_ranges,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_ranges {
    pub tqh_first: *mut style_range,
    pub tqh_last: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_range {
    pub type_0: style_range_type,
    pub argument: u_int,
    pub string: [libc::c_char; 16],
    pub start: u_int,
    pub end: u_int,
    pub entry: C2RustUnnamed_31,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_31 {
    pub tqe_next: *mut style_range,
    pub tqe_prev: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty {
    pub client: *mut client,
    pub start_timer: event,
    pub clipboard_timer: event,
    pub last_requests: time_t,
    pub sx: u_int,
    pub sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub ccolour: libc::c_int,
    pub oflag: libc::c_int,
    pub oox: u_int,
    pub ooy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub mode: libc::c_int,
    pub fg: libc::c_int,
    pub bg: libc::c_int,
    pub rlower: u_int,
    pub rupper: u_int,
    pub rleft: u_int,
    pub rright: u_int,
    pub event_in: event,
    pub in_0: *mut evbuffer,
    pub event_out: event,
    pub out: *mut evbuffer,
    pub timer: event,
    pub discarded: size_t,
    pub tio: termios,
    pub cell: grid_cell,
    pub last_cell: grid_cell,
    pub flags: libc::c_int,
    pub term: *mut tty_term,
    pub mouse_last_x: u_int,
    pub mouse_last_y: u_int,
    pub mouse_last_b: u_int,
    pub mouse_drag_flag: libc::c_int,
    pub mouse_scrolling_flag: libc::c_int,
    pub mouse_slider_mpos: libc::c_int,
    pub mouse_drag_update: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub mouse_drag_release: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub key_timer: event,
    pub key_tree: *mut tty_key,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_term {
    pub name: *mut libc::c_char,
    pub tty: *mut tty,
    pub features: libc::c_int,
    pub acs: [[libc::c_char; 2]; 256],
    pub codes: *mut tty_code,
    pub flags: libc::c_int,
    pub entry: C2RustUnnamed_32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_32 {
    pub le_next: *mut tty_term,
    pub le_prev: *mut *mut tty_term,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_windows {
    pub rbh_root: *mut client_window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_window {
    pub window: u_int,
    pub pane: *mut window_pane,
    pub sx: u_int,
    pub sy: u_int,
    pub entry: C2RustUnnamed_33,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_33 {
    pub rbe_left: *mut client_window,
    pub rbe_right: *mut client_window,
    pub rbe_parent: *mut client_window,
    pub rbe_color: libc::c_int,
}
#[no_mangle]
pub unsafe extern "C" fn layout_create_cell(mut lcparent: *mut layout_cell) -> *mut layout_cell {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    lc = xmalloc(::core::mem::size_of::<layout_cell>() as libc::c_ulong) as *mut layout_cell;
    (*lc).type_0 = LAYOUT_WINDOWPANE;
    (*lc).parent = lcparent;
    (*lc).cells.tqh_first = std::ptr::null_mut::<layout_cell>();
    (*lc).cells.tqh_last = &mut (*lc).cells.tqh_first;
    (*lc).sx = (2147483647 as libc::c_int as libc::c_uint)
        .wrapping_mul(2 as libc::c_uint)
        .wrapping_add(1 as libc::c_uint);
    (*lc).sy = (2147483647 as libc::c_int as libc::c_uint)
        .wrapping_mul(2 as libc::c_uint)
        .wrapping_add(1 as libc::c_uint);
    (*lc).xoff = (2147483647 as libc::c_int as libc::c_uint)
        .wrapping_mul(2 as libc::c_uint)
        .wrapping_add(1 as libc::c_uint);
    (*lc).yoff = (2147483647 as libc::c_int as libc::c_uint)
        .wrapping_mul(2 as libc::c_uint)
        .wrapping_add(1 as libc::c_uint);
    (*lc).wp = std::ptr::null_mut::<window_pane>();
    return lc;
}
#[no_mangle]
pub unsafe extern "C" fn layout_free_cell(mut lc: *mut layout_cell) {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    match (*lc).type_0 as libc::c_uint {
        0 | 1 => {
            while !((*lc).cells.tqh_first).is_null() {
                lcchild = (*lc).cells.tqh_first;
                if !((*lcchild).entry.tqe_next).is_null() {
                    (*(*lcchild).entry.tqe_next).entry.tqe_prev = (*lcchild).entry.tqe_prev;
                } else {
                    (*lc).cells.tqh_last = (*lcchild).entry.tqe_prev;
                }
                *(*lcchild).entry.tqe_prev = (*lcchild).entry.tqe_next;
                layout_free_cell(lcchild);
            }
        }
        2 => {
            if !((*lc).wp).is_null() {
                (*(*lc).wp).layout_cell = std::ptr::null_mut::<layout_cell>();
            }
        }
        _ => {}
    }
    free(lc as *mut libc::c_void);
}
#[no_mangle]
pub unsafe extern "C" fn layout_print_cell(
    mut lc: *mut layout_cell,
    mut hdr: *const libc::c_char,
    mut n: u_int,
) {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut type_0: *const libc::c_char = std::ptr::null::<libc::c_char>();
    match (*lc).type_0 as libc::c_uint {
        0 => {
            type_0 = b"LEFTRIGHT\0" as *const u8 as *const libc::c_char;
        }
        1 => {
            type_0 = b"TOPBOTTOM\0" as *const u8 as *const libc::c_char;
        }
        2 => {
            type_0 = b"WINDOWPANE\0" as *const u8 as *const libc::c_char;
        }
        _ => {
            type_0 = b"UNKNOWN\0" as *const u8 as *const libc::c_char;
        }
    }
    log_debug(
        b"%s:%*s%p type %s [parent %p] wp=%p [%u,%u %ux%u]\0" as *const u8 as *const libc::c_char,
        hdr,
        n,
        b" \0" as *const u8 as *const libc::c_char,
        lc,
        type_0,
        (*lc).parent,
        (*lc).wp,
        (*lc).xoff,
        (*lc).yoff,
        (*lc).sx,
        (*lc).sy,
    );
    match (*lc).type_0 as libc::c_uint {
        0 | 1 => {
            lcchild = (*lc).cells.tqh_first;
            while !lcchild.is_null() {
                layout_print_cell(
                    lcchild,
                    hdr,
                    n.wrapping_add(1 as libc::c_int as libc::c_uint),
                );
                lcchild = (*lcchild).entry.tqe_next;
            }
        }
        2 | _ => {}
    };
}
#[no_mangle]
pub unsafe extern "C" fn layout_search_by_border(
    mut lc: *mut layout_cell,
    mut x: u_int,
    mut y: u_int,
) -> *mut layout_cell {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut last: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    lcchild = (*lc).cells.tqh_first;
    while !lcchild.is_null() {
        if x >= (*lcchild).xoff
            && x < ((*lcchild).xoff).wrapping_add((*lcchild).sx)
            && y >= (*lcchild).yoff
            && y < ((*lcchild).yoff).wrapping_add((*lcchild).sy)
        {
            return layout_search_by_border(lcchild, x, y);
        }
        if last.is_null() {
            last = lcchild;
        } else {
            match (*lc).type_0 as libc::c_uint {
                0 => {
                    if x < (*lcchild).xoff && x >= ((*last).xoff).wrapping_add((*last).sx) {
                        return last;
                    }
                }
                1 => {
                    if y < (*lcchild).yoff && y >= ((*last).yoff).wrapping_add((*last).sy) {
                        return last;
                    }
                }
                2 | _ => {}
            }
            last = lcchild;
        }
        lcchild = (*lcchild).entry.tqe_next;
    }
    return std::ptr::null_mut::<layout_cell>();
}
#[no_mangle]
pub unsafe extern "C" fn layout_set_size(
    mut lc: *mut layout_cell,
    mut sx: u_int,
    mut sy: u_int,
    mut xoff: u_int,
    mut yoff: u_int,
) {
    (*lc).sx = sx;
    (*lc).sy = sy;
    (*lc).xoff = xoff;
    (*lc).yoff = yoff;
}
#[no_mangle]
pub unsafe extern "C" fn layout_make_leaf(mut lc: *mut layout_cell, mut wp: *mut window_pane) {
    (*lc).type_0 = LAYOUT_WINDOWPANE;
    (*lc).cells.tqh_first = std::ptr::null_mut::<layout_cell>();
    (*lc).cells.tqh_last = &mut (*lc).cells.tqh_first;
    (*wp).layout_cell = lc;
    (*lc).wp = wp;
}
#[no_mangle]
pub unsafe extern "C" fn layout_make_node(mut lc: *mut layout_cell, mut type_0: layout_type) {
    if type_0 as libc::c_uint == LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint {
        fatalx(b"bad layout type\0" as *const u8 as *const libc::c_char);
    }
    (*lc).type_0 = type_0;
    (*lc).cells.tqh_first = std::ptr::null_mut::<layout_cell>();
    (*lc).cells.tqh_last = &mut (*lc).cells.tqh_first;
    if !((*lc).wp).is_null() {
        (*(*lc).wp).layout_cell = std::ptr::null_mut::<layout_cell>();
    }
    (*lc).wp = std::ptr::null_mut::<window_pane>();
}
unsafe extern "C" fn layout_fix_offsets1(mut lc: *mut layout_cell) {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut xoff: u_int = 0;
    let mut yoff: u_int = 0;
    if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        xoff = (*lc).xoff;
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            (*lcchild).xoff = xoff;
            (*lcchild).yoff = (*lc).yoff;
            if (*lcchild).type_0 as libc::c_uint != LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint
            {
                layout_fix_offsets1(lcchild);
            }
            xoff = (xoff as libc::c_uint)
                .wrapping_add(((*lcchild).sx).wrapping_add(1 as libc::c_int as libc::c_uint))
                as u_int as u_int;
            lcchild = (*lcchild).entry.tqe_next;
        }
    } else {
        yoff = (*lc).yoff;
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            (*lcchild).xoff = (*lc).xoff;
            (*lcchild).yoff = yoff;
            if (*lcchild).type_0 as libc::c_uint != LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint
            {
                layout_fix_offsets1(lcchild);
            }
            yoff = (yoff as libc::c_uint)
                .wrapping_add(((*lcchild).sy).wrapping_add(1 as libc::c_int as libc::c_uint))
                as u_int as u_int;
            lcchild = (*lcchild).entry.tqe_next;
        }
    };
}
#[no_mangle]
pub unsafe extern "C" fn layout_fix_offsets(mut w: *mut window) {
    let mut lc: *mut layout_cell = (*w).layout_root;
    (*lc).xoff = 0 as libc::c_int as u_int;
    (*lc).yoff = 0 as libc::c_int as u_int;
    layout_fix_offsets1(lc);
}
unsafe extern "C" fn layout_cell_is_top(
    mut w: *mut window,
    mut lc: *mut layout_cell,
) -> libc::c_int {
    let mut next: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    while lc != (*w).layout_root {
        next = (*lc).parent;
        if (*next).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint
            && lc != (*next).cells.tqh_first
        {
            return 0 as libc::c_int;
        }
        lc = next;
    }
    return 1 as libc::c_int;
}
unsafe extern "C" fn layout_cell_is_bottom(
    mut w: *mut window,
    mut lc: *mut layout_cell,
) -> libc::c_int {
    let mut next: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    while lc != (*w).layout_root {
        next = (*lc).parent;
        if (*next).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint
            && lc != *(*((*next).cells.tqh_last as *mut layout_cells)).tqh_last
        {
            return 0 as libc::c_int;
        }
        lc = next;
    }
    return 1 as libc::c_int;
}
unsafe extern "C" fn layout_add_horizontal_border(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut status: libc::c_int,
) -> libc::c_int {
    if status == 1 as libc::c_int {
        return layout_cell_is_top(w, lc);
    }
    if status == 2 as libc::c_int {
        return layout_cell_is_bottom(w, lc);
    }
    return 0 as libc::c_int;
}
#[no_mangle]
pub unsafe extern "C" fn layout_fix_panes(mut w: *mut window, mut skip: *mut window_pane) {
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut status: libc::c_int = 0;
    let mut scrollbars: libc::c_int = 0;
    let mut sb_pos: libc::c_int = 0;
    let mut sb_w: libc::c_int = 0;
    let mut sb_pad: libc::c_int = 0;
    let mut sx: u_int = 0;
    let mut sy: u_int = 0;
    status = options_get_number(
        (*w).options,
        b"pane-border-status\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    scrollbars = options_get_number(
        (*w).options,
        b"pane-scrollbars\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    sb_pos = options_get_number(
        (*w).options,
        b"pane-scrollbars-position\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    wp = (*w).panes.tqh_first;
    while !wp.is_null() {
        lc = (*wp).layout_cell;
        if !(lc.is_null() || wp == skip) {
            (*wp).xoff = (*lc).xoff;
            (*wp).yoff = (*lc).yoff;
            sx = (*lc).sx;
            sy = (*lc).sy;
            if layout_add_horizontal_border(w, lc, status) != 0 {
                if status == 1 as libc::c_int {
                    (*wp).yoff = ((*wp).yoff).wrapping_add(1);
                }
                sy = sy.wrapping_sub(1);
            }
            if window_pane_show_scrollbar(wp, scrollbars) != 0 {
                sb_w = (*wp).scrollbar_style.width;
                sb_pad = (*wp).scrollbar_style.pad;
                if sb_w < 1 as libc::c_int {
                    sb_w = 1 as libc::c_int;
                }
                if sb_pad < 0 as libc::c_int {
                    sb_pad = 0 as libc::c_int;
                }
                if sb_pos == 1 as libc::c_int {
                    if sx as libc::c_int - sb_w < 1 as libc::c_int {
                        (*wp).xoff = ((*wp).xoff)
                            .wrapping_add(sx as libc::c_int as libc::c_uint)
                            .wrapping_sub(1 as libc::c_int as libc::c_uint);
                        sx = 1 as libc::c_int as u_int;
                    } else {
                        sx = sx
                            .wrapping_sub(sb_w as libc::c_uint)
                            .wrapping_sub(sb_pad as libc::c_uint);
                        (*wp).xoff = ((*wp).xoff)
                            .wrapping_add(sb_w as libc::c_uint)
                            .wrapping_add(sb_pad as libc::c_uint);
                    }
                } else if sx as libc::c_int - sb_w - sb_pad < 1 as libc::c_int {
                    sx = 1 as libc::c_int as u_int;
                } else {
                    sx = sx
                        .wrapping_sub(sb_w as libc::c_uint)
                        .wrapping_sub(sb_pad as libc::c_uint);
                }
                (*wp).flags |= 0x4000 as libc::c_int;
            }
            window_pane_resize(wp, sx, sy);
        }
        wp = (*wp).entry.tqe_next;
    }
}
#[no_mangle]
pub unsafe extern "C" fn layout_count_cells(mut lc: *mut layout_cell) -> u_int {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut count: u_int = 0;
    match (*lc).type_0 as libc::c_uint {
        2 => return 1 as libc::c_int as u_int,
        0 | 1 => {
            count = 0 as libc::c_int as u_int;
            lcchild = (*lc).cells.tqh_first;
            while !lcchild.is_null() {
                count = (count as libc::c_uint).wrapping_add(layout_count_cells(lcchild)) as u_int
                    as u_int;
                lcchild = (*lcchild).entry.tqe_next;
            }
            return count;
        }
        _ => {
            fatalx(b"bad layout type\0" as *const u8 as *const libc::c_char);
        }
    };
}
unsafe extern "C" fn layout_resize_check(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
) -> u_int {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut sb_style: *mut style = &mut (*(*w).active).scrollbar_style;
    let mut available: u_int = 0;
    let mut minimum: u_int = 0;
    let mut status: libc::c_int = 0;
    let mut scrollbars: libc::c_int = 0;
    status = options_get_number(
        (*w).options,
        b"pane-border-status\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    scrollbars = options_get_number(
        (*w).options,
        b"pane-scrollbars\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    if (*lc).type_0 as libc::c_uint == LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint {
        if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            available = (*lc).sx;
            if scrollbars != 0 {
                minimum = (1 as libc::c_int + (*sb_style).width + (*sb_style).pad) as u_int;
            } else {
                minimum = 1 as libc::c_int as u_int;
            }
        } else {
            available = (*lc).sy;
            if layout_add_horizontal_border(w, lc, status) != 0 {
                minimum = (1 as libc::c_int + 1 as libc::c_int) as u_int;
            } else {
                minimum = 1 as libc::c_int as u_int;
            }
        }
        if available > minimum {
            available = (available as libc::c_uint).wrapping_sub(minimum) as u_int as u_int;
        } else {
            available = 0 as libc::c_int as u_int;
        }
    } else if (*lc).type_0 as libc::c_uint == type_0 as libc::c_uint {
        available = 0 as libc::c_int as u_int;
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            available = (available as libc::c_uint)
                .wrapping_add(layout_resize_check(w, lcchild, type_0))
                as u_int as u_int;
            lcchild = (*lcchild).entry.tqe_next;
        }
    } else {
        minimum = (2147483647 as libc::c_int as libc::c_uint)
            .wrapping_mul(2 as libc::c_uint)
            .wrapping_add(1 as libc::c_uint);
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            available = layout_resize_check(w, lcchild, type_0);
            if available < minimum {
                minimum = available;
            }
            lcchild = (*lcchild).entry.tqe_next;
        }
        available = minimum;
    }
    return available;
}
#[no_mangle]
pub unsafe extern "C" fn layout_resize_adjust(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut change: libc::c_int,
) {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        (*lc).sx =
            ((*lc).sx as libc::c_uint).wrapping_add(change as libc::c_uint) as u_int as u_int;
    } else {
        (*lc).sy =
            ((*lc).sy as libc::c_uint).wrapping_add(change as libc::c_uint) as u_int as u_int;
    }
    if type_0 as libc::c_uint == LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint {
        return;
    }
    if (*lc).type_0 as libc::c_uint != type_0 as libc::c_uint {
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            layout_resize_adjust(w, lcchild, type_0, change);
            lcchild = (*lcchild).entry.tqe_next;
        }
        return;
    }
    while change != 0 as libc::c_int {
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            if change == 0 as libc::c_int {
                break;
            }
            if change > 0 as libc::c_int {
                layout_resize_adjust(w, lcchild, type_0, 1 as libc::c_int);
                change -= 1;
            } else if layout_resize_check(w, lcchild, type_0) > 0 as libc::c_int as libc::c_uint {
                layout_resize_adjust(w, lcchild, type_0, -(1 as libc::c_int));
                change += 1;
            }
            lcchild = (*lcchild).entry.tqe_next;
        }
    }
}
#[no_mangle]
pub unsafe extern "C" fn layout_destroy_cell(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut lcroot: *mut *mut layout_cell,
) {
    let mut lcother: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcparent: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    lcparent = (*lc).parent;
    if lcparent.is_null() {
        layout_free_cell(lc);
        *lcroot = std::ptr::null_mut::<layout_cell>();
        return;
    }
    if lc == (*lcparent).cells.tqh_first {
        lcother = (*lc).entry.tqe_next;
    } else {
        lcother = *(*((*lc).entry.tqe_prev as *mut layout_cells)).tqh_last;
    }
    if !lcother.is_null()
        && (*lcparent).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint
    {
        layout_resize_adjust(
            w,
            lcother,
            (*lcparent).type_0,
            ((*lc).sx).wrapping_add(1 as libc::c_int as libc::c_uint) as libc::c_int,
        );
    } else if !lcother.is_null() {
        layout_resize_adjust(
            w,
            lcother,
            (*lcparent).type_0,
            ((*lc).sy).wrapping_add(1 as libc::c_int as libc::c_uint) as libc::c_int,
        );
    }
    if !((*lc).entry.tqe_next).is_null() {
        (*(*lc).entry.tqe_next).entry.tqe_prev = (*lc).entry.tqe_prev;
    } else {
        (*lcparent).cells.tqh_last = (*lc).entry.tqe_prev;
    }
    *(*lc).entry.tqe_prev = (*lc).entry.tqe_next;
    layout_free_cell(lc);
    lc = (*lcparent).cells.tqh_first;
    if ((*lc).entry.tqe_next).is_null() {
        if !((*lc).entry.tqe_next).is_null() {
            (*(*lc).entry.tqe_next).entry.tqe_prev = (*lc).entry.tqe_prev;
        } else {
            (*lcparent).cells.tqh_last = (*lc).entry.tqe_prev;
        }
        *(*lc).entry.tqe_prev = (*lc).entry.tqe_next;
        (*lc).parent = (*lcparent).parent;
        if ((*lc).parent).is_null() {
            (*lc).xoff = 0 as libc::c_int as u_int;
            (*lc).yoff = 0 as libc::c_int as u_int;
            *lcroot = lc;
        } else {
            (*lc).entry.tqe_next = (*lcparent).entry.tqe_next;
            if !((*lc).entry.tqe_next).is_null() {
                (*(*lc).entry.tqe_next).entry.tqe_prev = &mut (*lc).entry.tqe_next;
            } else {
                (*(*lc).parent).cells.tqh_last = &mut (*lc).entry.tqe_next;
            }
            (*lc).entry.tqe_prev = (*lcparent).entry.tqe_prev;
            *(*lc).entry.tqe_prev = lc;
        }
        layout_free_cell(lcparent);
    }
}
#[no_mangle]
pub unsafe extern "C" fn layout_init(mut w: *mut window, mut wp: *mut window_pane) {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    (*w).layout_root = layout_create_cell(std::ptr::null_mut::<layout_cell>());
    lc = (*w).layout_root;
    layout_set_size(
        lc,
        (*w).sx,
        (*w).sy,
        0 as libc::c_int as u_int,
        0 as libc::c_int as u_int,
    );
    layout_make_leaf(lc, wp);
    layout_fix_panes(w, std::ptr::null_mut::<window_pane>());
}
#[no_mangle]
pub unsafe extern "C" fn layout_free(mut w: *mut window) {
    layout_free_cell((*w).layout_root);
}
#[no_mangle]
pub unsafe extern "C" fn layout_resize(mut w: *mut window, mut sx: u_int, mut sy: u_int) {
    let mut lc: *mut layout_cell = (*w).layout_root;
    let mut xlimit: libc::c_int = 0;
    let mut ylimit: libc::c_int = 0;
    let mut xchange: libc::c_int = 0;
    let mut ychange: libc::c_int = 0;
    xchange = sx.wrapping_sub((*lc).sx) as libc::c_int;
    xlimit = layout_resize_check(w, lc, LAYOUT_LEFTRIGHT) as libc::c_int;
    if xchange < 0 as libc::c_int && xchange < -xlimit {
        xchange = -xlimit;
    }
    if xlimit == 0 as libc::c_int {
        if sx <= (*lc).sx {
            xchange = 0 as libc::c_int;
        } else {
            xchange = sx.wrapping_sub((*lc).sx) as libc::c_int;
        }
    }
    if xchange != 0 as libc::c_int {
        layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, xchange);
    }
    ychange = sy.wrapping_sub((*lc).sy) as libc::c_int;
    ylimit = layout_resize_check(w, lc, LAYOUT_TOPBOTTOM) as libc::c_int;
    if ychange < 0 as libc::c_int && ychange < -ylimit {
        ychange = -ylimit;
    }
    if ylimit == 0 as libc::c_int {
        if sy <= (*lc).sy {
            ychange = 0 as libc::c_int;
        } else {
            ychange = sy.wrapping_sub((*lc).sy) as libc::c_int;
        }
    }
    if ychange != 0 as libc::c_int {
        layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, ychange);
    }
    layout_fix_offsets(w);
    layout_fix_panes(w, std::ptr::null_mut::<window_pane>());
}
#[no_mangle]
pub unsafe extern "C" fn layout_resize_pane_to(
    mut wp: *mut window_pane,
    mut type_0: layout_type,
    mut new_size: u_int,
) {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcparent: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut change: libc::c_int = 0;
    let mut size: libc::c_int = 0;
    lc = (*wp).layout_cell;
    lcparent = (*lc).parent;
    while !lcparent.is_null() && (*lcparent).type_0 as libc::c_uint != type_0 as libc::c_uint {
        lc = lcparent;
        lcparent = (*lc).parent;
    }
    if lcparent.is_null() {
        return;
    }
    if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        size = (*lc).sx as libc::c_int;
    } else {
        size = (*lc).sy as libc::c_int;
    }
    if lc == *(*((*lcparent).cells.tqh_last as *mut layout_cells)).tqh_last {
        change = (size as libc::c_uint).wrapping_sub(new_size) as libc::c_int;
    } else {
        change = new_size.wrapping_sub(size as libc::c_uint) as libc::c_int;
    }
    layout_resize_pane(wp, type_0, change, 1 as libc::c_int);
}
#[no_mangle]
pub unsafe extern "C" fn layout_resize_layout(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut change: libc::c_int,
    mut opposite: libc::c_int,
) {
    let mut needed: libc::c_int = 0;
    let mut size: libc::c_int = 0;
    needed = change;
    while needed != 0 as libc::c_int {
        if change > 0 as libc::c_int {
            size = layout_resize_pane_grow(w, lc, type_0, needed, opposite);
            needed -= size;
        } else {
            size = layout_resize_pane_shrink(w, lc, type_0, needed);
            needed += size;
        }
        if size == 0 as libc::c_int {
            break;
        }
    }
    layout_fix_offsets(w);
    layout_fix_panes(w, std::ptr::null_mut::<window_pane>());
    notify_window(
        b"window-layout-changed\0" as *const u8 as *const libc::c_char,
        w,
    );
}
#[no_mangle]
pub unsafe extern "C" fn layout_resize_pane(
    mut wp: *mut window_pane,
    mut type_0: layout_type,
    mut change: libc::c_int,
    mut opposite: libc::c_int,
) {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcparent: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    lc = (*wp).layout_cell;
    lcparent = (*lc).parent;
    while !lcparent.is_null() && (*lcparent).type_0 as libc::c_uint != type_0 as libc::c_uint {
        lc = lcparent;
        lcparent = (*lc).parent;
    }
    if lcparent.is_null() {
        return;
    }
    if lc == *(*((*lcparent).cells.tqh_last as *mut layout_cells)).tqh_last {
        lc = *(*((*lc).entry.tqe_prev as *mut layout_cells)).tqh_last;
    }
    layout_resize_layout((*wp).window, lc, type_0, change, opposite);
}
unsafe extern "C" fn layout_resize_pane_grow(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut needed: libc::c_int,
    mut opposite: libc::c_int,
) -> libc::c_int {
    let mut lcadd: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcremove: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut size: u_int = 0 as libc::c_int as u_int;
    lcadd = lc;
    lcremove = (*lc).entry.tqe_next;
    while !lcremove.is_null() {
        size = layout_resize_check(w, lcremove, type_0);
        if size > 0 as libc::c_int as libc::c_uint {
            break;
        }
        lcremove = (*lcremove).entry.tqe_next;
    }
    if opposite != 0 && lcremove.is_null() {
        lcremove = *(*((*lc).entry.tqe_prev as *mut layout_cells)).tqh_last;
        while !lcremove.is_null() {
            size = layout_resize_check(w, lcremove, type_0);
            if size > 0 as libc::c_int as libc::c_uint {
                break;
            }
            lcremove = *(*((*lcremove).entry.tqe_prev as *mut layout_cells)).tqh_last;
        }
    }
    if lcremove.is_null() {
        return 0 as libc::c_int;
    }
    if size > needed as u_int {
        size = needed as u_int;
    }
    layout_resize_adjust(w, lcadd, type_0, size as libc::c_int);
    layout_resize_adjust(w, lcremove, type_0, size.wrapping_neg() as libc::c_int);
    return size as libc::c_int;
}
unsafe extern "C" fn layout_resize_pane_shrink(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut needed: libc::c_int,
) -> libc::c_int {
    let mut lcadd: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcremove: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut size: u_int = 0;
    lcremove = lc;
    loop {
        size = layout_resize_check(w, lcremove, type_0);
        if size != 0 as libc::c_int as libc::c_uint {
            break;
        }
        lcremove = *(*((*lcremove).entry.tqe_prev as *mut layout_cells)).tqh_last;
        if lcremove.is_null() {
            break;
        }
    }
    if lcremove.is_null() {
        return 0 as libc::c_int;
    }
    lcadd = (*lc).entry.tqe_next;
    if lcadd.is_null() {
        return 0 as libc::c_int;
    }
    if size > -needed as u_int {
        size = -needed as u_int;
    }
    layout_resize_adjust(w, lcadd, type_0, size as libc::c_int);
    layout_resize_adjust(w, lcremove, type_0, size.wrapping_neg() as libc::c_int);
    return size as libc::c_int;
}
#[no_mangle]
pub unsafe extern "C" fn layout_assign_pane(
    mut lc: *mut layout_cell,
    mut wp: *mut window_pane,
    mut do_not_resize: libc::c_int,
) {
    layout_make_leaf(lc, wp);
    if do_not_resize != 0 {
        layout_fix_panes((*wp).window, wp);
    } else {
        layout_fix_panes((*wp).window, std::ptr::null_mut::<window_pane>());
    };
}
unsafe extern "C" fn layout_new_pane_size(
    mut w: *mut window,
    mut previous: u_int,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut size: u_int,
    mut count_left: u_int,
    mut size_left: u_int,
) -> u_int {
    let mut new_size: u_int = 0;
    let mut min: u_int = 0;
    let mut max: u_int = 0;
    let mut available: u_int = 0;
    if count_left == 1 as libc::c_int as libc::c_uint {
        return size_left;
    }
    available = layout_resize_check(w, lc, type_0);
    min = ((1 as libc::c_int + 1 as libc::c_int) as libc::c_uint)
        .wrapping_mul(count_left.wrapping_sub(1 as libc::c_int as libc::c_uint));
    if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        if ((*lc).sx).wrapping_sub(available) > min {
            min = ((*lc).sx).wrapping_sub(available);
        }
        new_size = ((*lc).sx).wrapping_mul(size).wrapping_div(previous);
    } else {
        if ((*lc).sy).wrapping_sub(available) > min {
            min = ((*lc).sy).wrapping_sub(available);
        }
        new_size = ((*lc).sy).wrapping_mul(size).wrapping_div(previous);
    }
    max = size_left.wrapping_sub(min);
    if new_size > max {
        new_size = max;
    }
    if new_size < 1 as libc::c_int as libc::c_uint {
        new_size = 1 as libc::c_int as u_int;
    }
    return new_size;
}
unsafe extern "C" fn layout_set_size_check(
    mut w: *mut window,
    mut lc: *mut layout_cell,
    mut type_0: layout_type,
    mut size: libc::c_int,
) -> libc::c_int {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut new_size: u_int = 0;
    let mut available: u_int = 0;
    let mut previous: u_int = 0;
    let mut count: u_int = 0;
    let mut idx: u_int = 0;
    if (*lc).type_0 as libc::c_uint == LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint {
        return (size >= 1 as libc::c_int) as libc::c_int;
    }
    available = size as u_int;
    count = 0 as libc::c_int as u_int;
    lcchild = (*lc).cells.tqh_first;
    while !lcchild.is_null() {
        count = count.wrapping_add(1);
        lcchild = (*lcchild).entry.tqe_next;
    }
    if (*lc).type_0 as libc::c_uint == type_0 as libc::c_uint {
        if available
            < count
                .wrapping_mul(2 as libc::c_int as libc::c_uint)
                .wrapping_sub(1 as libc::c_int as libc::c_uint)
        {
            return 0 as libc::c_int;
        }
        if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            previous = (*lc).sx;
        } else {
            previous = (*lc).sy;
        }
        idx = 0 as libc::c_int as u_int;
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            new_size = layout_new_pane_size(
                w,
                previous,
                lcchild,
                type_0,
                size as u_int,
                count.wrapping_sub(idx),
                available,
            );
            if idx == count.wrapping_sub(1 as libc::c_int as libc::c_uint) {
                if new_size > available {
                    return 0 as libc::c_int;
                }
                available = (available as libc::c_uint).wrapping_sub(new_size) as u_int as u_int;
            } else {
                if new_size.wrapping_add(1 as libc::c_int as libc::c_uint) > available {
                    return 0 as libc::c_int;
                }
                available = (available as libc::c_uint)
                    .wrapping_sub(new_size.wrapping_add(1 as libc::c_int as libc::c_uint))
                    as u_int as u_int;
            }
            if layout_set_size_check(w, lcchild, type_0, new_size as libc::c_int) == 0 {
                return 0 as libc::c_int;
            }
            idx = idx.wrapping_add(1);
            lcchild = (*lcchild).entry.tqe_next;
        }
    } else {
        lcchild = (*lc).cells.tqh_first;
        while !lcchild.is_null() {
            if (*lcchild).type_0 as libc::c_uint != LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint
            {
                if layout_set_size_check(w, lcchild, type_0, size) == 0 {
                    return 0 as libc::c_int;
                }
            }
            lcchild = (*lcchild).entry.tqe_next;
        }
    }
    return 1 as libc::c_int;
}
unsafe extern "C" fn layout_resize_child_cells(mut w: *mut window, mut lc: *mut layout_cell) {
    let mut lcchild: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut previous: u_int = 0;
    let mut available: u_int = 0;
    let mut count: u_int = 0;
    let mut idx: u_int = 0;
    if (*lc).type_0 as libc::c_uint == LAYOUT_WINDOWPANE as libc::c_int as libc::c_uint {
        return;
    }
    count = 0 as libc::c_int as u_int;
    previous = 0 as libc::c_int as u_int;
    lcchild = (*lc).cells.tqh_first;
    while !lcchild.is_null() {
        count = count.wrapping_add(1);
        if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            previous = (previous as libc::c_uint).wrapping_add((*lcchild).sx) as u_int as u_int;
        } else if (*lc).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
            previous = (previous as libc::c_uint).wrapping_add((*lcchild).sy) as u_int as u_int;
        }
        lcchild = (*lcchild).entry.tqe_next;
    }
    previous = (previous as libc::c_uint)
        .wrapping_add(count.wrapping_sub(1 as libc::c_int as libc::c_uint)) as u_int
        as u_int;
    available = 0 as libc::c_int as u_int;
    if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        available = (*lc).sx;
    } else if (*lc).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
        available = (*lc).sy;
    }
    idx = 0 as libc::c_int as u_int;
    lcchild = (*lc).cells.tqh_first;
    while !lcchild.is_null() {
        if (*lc).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
            (*lcchild).sx = (*lc).sx;
            (*lcchild).xoff = (*lc).xoff;
        } else {
            (*lcchild).sx = layout_new_pane_size(
                w,
                previous,
                lcchild,
                (*lc).type_0,
                (*lc).sx,
                count.wrapping_sub(idx),
                available,
            );
            available = (available as libc::c_uint)
                .wrapping_sub(((*lcchild).sx).wrapping_add(1 as libc::c_int as libc::c_uint))
                as u_int as u_int;
        }
        if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            (*lcchild).sy = (*lc).sy;
        } else {
            (*lcchild).sy = layout_new_pane_size(
                w,
                previous,
                lcchild,
                (*lc).type_0,
                (*lc).sy,
                count.wrapping_sub(idx),
                available,
            );
            available = (available as libc::c_uint)
                .wrapping_sub(((*lcchild).sy).wrapping_add(1 as libc::c_int as libc::c_uint))
                as u_int as u_int;
        }
        layout_resize_child_cells(w, lcchild);
        idx = idx.wrapping_add(1);
        lcchild = (*lcchild).entry.tqe_next;
    }
}
#[no_mangle]
pub unsafe extern "C" fn layout_split_pane(
    mut wp: *mut window_pane,
    mut type_0: layout_type,
    mut size: libc::c_int,
    mut flags: libc::c_int,
) -> *mut layout_cell {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcparent: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lcnew: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lc1: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut lc2: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut sb_style: *mut style = &mut (*wp).scrollbar_style;
    let mut sx: u_int = 0;
    let mut sy: u_int = 0;
    let mut xoff: u_int = 0;
    let mut yoff: u_int = 0;
    let mut size1: u_int = 0;
    let mut size2: u_int = 0;
    let mut minimum: u_int = 0;
    let mut new_size: u_int = 0;
    let mut saved_size: u_int = 0;
    let mut resize_first: u_int = 0 as libc::c_int as u_int;
    let mut full_size: libc::c_int = flags & 0x20 as libc::c_int;
    let mut status: libc::c_int = 0;
    let mut scrollbars: libc::c_int = 0;
    if full_size != 0 {
        lc = (*(*wp).window).layout_root;
    } else {
        lc = (*wp).layout_cell;
    }
    status = options_get_number(
        (*(*wp).window).options,
        b"pane-border-status\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    scrollbars = options_get_number(
        (*(*wp).window).options,
        b"pane-scrollbars\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    sx = (*lc).sx;
    sy = (*lc).sy;
    xoff = (*lc).xoff;
    yoff = (*lc).yoff;
    match type_0 as libc::c_uint {
        0 => {
            if scrollbars != 0 {
                minimum = (1 as libc::c_int * 2 as libc::c_int
                    + (*sb_style).width
                    + (*sb_style).pad) as u_int;
            } else {
                minimum = (1 as libc::c_int * 2 as libc::c_int + 1 as libc::c_int) as u_int;
            }
            if sx < minimum {
                return std::ptr::null_mut::<layout_cell>();
            }
        }
        1 => {
            if layout_add_horizontal_border((*wp).window, lc, status) != 0 {
                minimum = (1 as libc::c_int * 2 as libc::c_int + 2 as libc::c_int) as u_int;
            } else {
                minimum = (1 as libc::c_int * 2 as libc::c_int + 1 as libc::c_int) as u_int;
            }
            if sy < minimum {
                return std::ptr::null_mut::<layout_cell>();
            }
        }
        _ => {
            fatalx(b"bad layout type\0" as *const u8 as *const libc::c_char);
        }
    }
    if type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        saved_size = sx;
    } else {
        saved_size = sy;
    }
    if size < 0 as libc::c_int {
        size2 = saved_size
            .wrapping_add(1 as libc::c_int as libc::c_uint)
            .wrapping_div(2 as libc::c_int as libc::c_uint)
            .wrapping_sub(1 as libc::c_int as libc::c_uint);
    } else if flags & 0x8 as libc::c_int != 0 {
        size2 = saved_size
            .wrapping_sub(size as libc::c_uint)
            .wrapping_sub(1 as libc::c_int as libc::c_uint);
    } else {
        size2 = size as u_int;
    }
    if size2 < 1 as libc::c_int as libc::c_uint {
        size2 = 1 as libc::c_int as u_int;
    } else if size2 > saved_size.wrapping_sub(2 as libc::c_int as libc::c_uint) {
        size2 = saved_size.wrapping_sub(2 as libc::c_int as libc::c_uint);
    }
    size1 = saved_size
        .wrapping_sub(1 as libc::c_int as libc::c_uint)
        .wrapping_sub(size2);
    if flags & 0x8 as libc::c_int != 0 {
        new_size = size2;
    } else {
        new_size = size1;
    }
    if full_size != 0
        && layout_set_size_check((*wp).window, lc, type_0, new_size as libc::c_int) == 0
    {
        return std::ptr::null_mut::<layout_cell>();
    }
    if !((*lc).parent).is_null() && (*(*lc).parent).type_0 as libc::c_uint == type_0 as libc::c_uint
    {
        lcparent = (*lc).parent;
        lcnew = layout_create_cell(lcparent);
        if flags & 0x8 as libc::c_int != 0 {
            (*lcnew).entry.tqe_prev = (*lc).entry.tqe_prev;
            (*lcnew).entry.tqe_next = lc;
            *(*lc).entry.tqe_prev = lcnew;
            (*lc).entry.tqe_prev = &mut (*lcnew).entry.tqe_next;
        } else {
            (*lcnew).entry.tqe_next = (*lc).entry.tqe_next;
            if !((*lcnew).entry.tqe_next).is_null() {
                (*(*lcnew).entry.tqe_next).entry.tqe_prev = &mut (*lcnew).entry.tqe_next;
            } else {
                (*lcparent).cells.tqh_last = &mut (*lcnew).entry.tqe_next;
            }
            (*lc).entry.tqe_next = lcnew;
            (*lcnew).entry.tqe_prev = &mut (*lc).entry.tqe_next;
        }
    } else if full_size != 0
        && ((*lc).parent).is_null()
        && (*lc).type_0 as libc::c_uint == type_0 as libc::c_uint
    {
        if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            (*lc).sx = new_size;
            layout_resize_child_cells((*wp).window, lc);
            (*lc).sx = saved_size;
        } else if (*lc).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
            (*lc).sy = new_size;
            layout_resize_child_cells((*wp).window, lc);
            (*lc).sy = saved_size;
        }
        resize_first = 1 as libc::c_int as u_int;
        lcnew = layout_create_cell(lc);
        size = saved_size
            .wrapping_sub(1 as libc::c_int as libc::c_uint)
            .wrapping_sub(new_size) as libc::c_int;
        if (*lc).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            layout_set_size(
                lcnew,
                size as u_int,
                sy,
                0 as libc::c_int as u_int,
                0 as libc::c_int as u_int,
            );
        } else if (*lc).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
            layout_set_size(
                lcnew,
                sx,
                size as u_int,
                0 as libc::c_int as u_int,
                0 as libc::c_int as u_int,
            );
        }
        if flags & 0x8 as libc::c_int != 0 {
            (*lcnew).entry.tqe_next = (*lc).cells.tqh_first;
            if !((*lcnew).entry.tqe_next).is_null() {
                (*(*lc).cells.tqh_first).entry.tqe_prev = &mut (*lcnew).entry.tqe_next;
            } else {
                (*lc).cells.tqh_last = &mut (*lcnew).entry.tqe_next;
            }
            (*lc).cells.tqh_first = lcnew;
            (*lcnew).entry.tqe_prev = &mut (*lc).cells.tqh_first;
        } else {
            (*lcnew).entry.tqe_next = std::ptr::null_mut::<layout_cell>();
            (*lcnew).entry.tqe_prev = (*lc).cells.tqh_last;
            *(*lc).cells.tqh_last = lcnew;
            (*lc).cells.tqh_last = &mut (*lcnew).entry.tqe_next;
        }
    } else {
        lcparent = layout_create_cell((*lc).parent);
        layout_make_node(lcparent, type_0);
        layout_set_size(lcparent, sx, sy, xoff, yoff);
        if ((*lc).parent).is_null() {
            (*(*wp).window).layout_root = lcparent;
        } else {
            (*lcparent).entry.tqe_next = (*lc).entry.tqe_next;
            if !((*lcparent).entry.tqe_next).is_null() {
                (*(*lcparent).entry.tqe_next).entry.tqe_prev = &mut (*lcparent).entry.tqe_next;
            } else {
                (*(*lc).parent).cells.tqh_last = &mut (*lcparent).entry.tqe_next;
            }
            (*lcparent).entry.tqe_prev = (*lc).entry.tqe_prev;
            *(*lcparent).entry.tqe_prev = lcparent;
        }
        (*lc).parent = lcparent;
        (*lc).entry.tqe_next = (*lcparent).cells.tqh_first;
        if !((*lc).entry.tqe_next).is_null() {
            (*(*lcparent).cells.tqh_first).entry.tqe_prev = &mut (*lc).entry.tqe_next;
        } else {
            (*lcparent).cells.tqh_last = &mut (*lc).entry.tqe_next;
        }
        (*lcparent).cells.tqh_first = lc;
        (*lc).entry.tqe_prev = &mut (*lcparent).cells.tqh_first;
        lcnew = layout_create_cell(lcparent);
        if flags & 0x8 as libc::c_int != 0 {
            (*lcnew).entry.tqe_next = (*lcparent).cells.tqh_first;
            if !((*lcnew).entry.tqe_next).is_null() {
                (*(*lcparent).cells.tqh_first).entry.tqe_prev = &mut (*lcnew).entry.tqe_next;
            } else {
                (*lcparent).cells.tqh_last = &mut (*lcnew).entry.tqe_next;
            }
            (*lcparent).cells.tqh_first = lcnew;
            (*lcnew).entry.tqe_prev = &mut (*lcparent).cells.tqh_first;
        } else {
            (*lcnew).entry.tqe_next = std::ptr::null_mut::<layout_cell>();
            (*lcnew).entry.tqe_prev = (*lcparent).cells.tqh_last;
            *(*lcparent).cells.tqh_last = lcnew;
            (*lcparent).cells.tqh_last = &mut (*lcnew).entry.tqe_next;
        }
    }
    if flags & 0x8 as libc::c_int != 0 {
        lc1 = lcnew;
        lc2 = lc;
    } else {
        lc1 = lc;
        lc2 = lcnew;
    }
    if resize_first == 0
        && type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint
    {
        layout_set_size(lc1, size1, sy, xoff, yoff);
        layout_set_size(
            lc2,
            size2,
            sy,
            xoff.wrapping_add((*lc1).sx)
                .wrapping_add(1 as libc::c_int as libc::c_uint),
            yoff,
        );
    } else if resize_first == 0
        && type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint
    {
        layout_set_size(lc1, sx, size1, xoff, yoff);
        layout_set_size(
            lc2,
            sx,
            size2,
            xoff,
            yoff.wrapping_add((*lc1).sy)
                .wrapping_add(1 as libc::c_int as libc::c_uint),
        );
    }
    if full_size != 0 {
        if resize_first == 0 {
            layout_resize_child_cells((*wp).window, lc);
        }
        layout_fix_offsets((*wp).window);
    } else {
        layout_make_leaf(lc, wp);
    }
    return lcnew;
}
#[no_mangle]
pub unsafe extern "C" fn layout_close_pane(mut wp: *mut window_pane) {
    let mut w: *mut window = (*wp).window;
    layout_destroy_cell(w, (*wp).layout_cell, &mut (*w).layout_root);
    if !((*w).layout_root).is_null() {
        layout_fix_offsets(w);
        layout_fix_panes(w, std::ptr::null_mut::<window_pane>());
    }
    notify_window(
        b"window-layout-changed\0" as *const u8 as *const libc::c_char,
        w,
    );
}
#[no_mangle]
pub unsafe extern "C" fn layout_spread_cell(
    mut w: *mut window,
    mut parent: *mut layout_cell,
) -> libc::c_int {
    let mut lc: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut sb_style: *mut style = &mut (*(*w).active).scrollbar_style;
    let mut number: u_int = 0;
    let mut each: u_int = 0;
    let mut size: u_int = 0;
    let mut this: u_int = 0;
    let mut change: libc::c_int = 0;
    let mut changed: libc::c_int = 0;
    let mut status: libc::c_int = 0;
    let mut scrollbars: libc::c_int = 0;
    number = 0 as libc::c_int as u_int;
    lc = (*parent).cells.tqh_first;
    while !lc.is_null() {
        number = number.wrapping_add(1);
        lc = (*lc).entry.tqe_next;
    }
    if number <= 1 as libc::c_int as libc::c_uint {
        return 0 as libc::c_int;
    }
    status = options_get_number(
        (*w).options,
        b"pane-border-status\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    scrollbars = options_get_number(
        (*w).options,
        b"pane-scrollbars\0" as *const u8 as *const libc::c_char,
    ) as libc::c_int;
    if (*parent).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
        if scrollbars != 0 {
            size = ((*parent).sx)
                .wrapping_sub((*sb_style).width as libc::c_uint)
                .wrapping_add((*sb_style).pad as libc::c_uint);
        } else {
            size = (*parent).sx;
        }
    } else if (*parent).type_0 as libc::c_uint == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint {
        if layout_add_horizontal_border(w, parent, status) != 0 {
            size = ((*parent).sy).wrapping_sub(1 as libc::c_int as libc::c_uint);
        } else {
            size = (*parent).sy;
        }
    } else {
        return 0 as libc::c_int;
    }
    if size < number.wrapping_sub(1 as libc::c_int as libc::c_uint) {
        return 0 as libc::c_int;
    }
    each = size
        .wrapping_sub(number.wrapping_sub(1 as libc::c_int as libc::c_uint))
        .wrapping_div(number);
    if each == 0 as libc::c_int as libc::c_uint {
        return 0 as libc::c_int;
    }
    changed = 0 as libc::c_int;
    lc = (*parent).cells.tqh_first;
    while !lc.is_null() {
        if ((*lc).entry.tqe_next).is_null() {
            each = size.wrapping_sub(
                each.wrapping_add(1 as libc::c_int as libc::c_uint)
                    .wrapping_mul(number.wrapping_sub(1 as libc::c_int as libc::c_uint)),
            );
        }
        change = 0 as libc::c_int;
        if (*parent).type_0 as libc::c_uint == LAYOUT_LEFTRIGHT as libc::c_int as libc::c_uint {
            change = each.wrapping_sub((*lc).sx as libc::c_int as libc::c_uint) as libc::c_int;
            layout_resize_adjust(w, lc, LAYOUT_LEFTRIGHT, change);
        } else if (*parent).type_0 as libc::c_uint
            == LAYOUT_TOPBOTTOM as libc::c_int as libc::c_uint
        {
            if layout_add_horizontal_border(w, lc, status) != 0 {
                this = each.wrapping_add(1 as libc::c_int as libc::c_uint);
            } else {
                this = each;
            }
            change = this.wrapping_sub((*lc).sy as libc::c_int as libc::c_uint) as libc::c_int;
            layout_resize_adjust(w, lc, LAYOUT_TOPBOTTOM, change);
        }
        if change != 0 as libc::c_int {
            changed = 1 as libc::c_int;
        }
        lc = (*lc).entry.tqe_next;
    }
    return changed;
}
#[no_mangle]
pub unsafe extern "C" fn layout_spread_out(mut wp: *mut window_pane) {
    let mut parent: *mut layout_cell = std::ptr::null_mut::<layout_cell>();
    let mut w: *mut window = (*wp).window;
    parent = (*(*wp).layout_cell).parent;
    if parent.is_null() {
        return;
    }
    loop {
        if layout_spread_cell(w, parent) != 0 {
            layout_fix_offsets(w);
            layout_fix_panes(w, std::ptr::null_mut::<window_pane>());
            break;
        } else {
            parent = (*parent).parent;
            if parent.is_null() {
                break;
            }
        }
    }
}
